package main

import "fmt"

// main
//
//	@Description: 冒泡排序：时间复杂度为 O(n^2)，其中 (n) 是数组的长度。
//
// 时间复杂度：效率从高到低~
// 常数时间复杂度 O(1)：
// 算法的执行时间不随输入规模的变化而变化。 例如，访问数组中的某个元素。

// 对数时间复杂度 O(log n)：
// 算法的执行时间随着输入规模的增加而对数增长。 例如，二分查找算法。

// 线性时间复杂度 O(n)：
// 算法的执行时间与输入规模成正比。 例如，遍历一个数组。

// 线性对数时间复杂度 O(n \log n)：
// 算法的执行时间与输入规模成线性对数关系。 例如，快速排序和归并排序在平均情况下的时间复杂度。

// 平方时间复杂度 O(n^2)：
// 算法的执行时间与输入规模的平方成正比。 例如，冒泡排序和选择排序。

// 立方时间复杂度 O(n^3)：
// 算法的执行时间与输入规模的立方成正比。 例如，某些矩阵乘法算法。

// 指数时间复杂度 O(2^n)：
// 算法的执行时间随着输入规模的增加而指数增长。 例如，解决某些组合问题的暴力方法。

// 阶乘时间复杂度 O(n!)：
// 算法的执行时间随着输入规模的增加而阶乘增长。
// 例如，生成所有排列的算法。
func main() {
	var arr [10]int = [10]int{34, 6, 79, 66, 22, 43, 1, 25, 89, 6}
	BubbleSortMinToMax(arr)

	BubbleSortMaxToMin(arr)

}

// BubbleSortMinToMax
//
//	@Description: 冒泡排序：正序
func BubbleSortMinToMax(arr [10]int) {
	fmt.Println("前=", arr)
	var maxTemp = 0
	//排序次数
	for times := 0; times < len(arr)-1; times++ {
		//从第一个开始，将最大的放到最后
		for i := 0; i < len(arr)-1-times; i++ {
			//如果前面的比后面大，则交换
			if arr[i] > arr[i+1] {
				maxTemp = arr[i+1]
				arr[i+1] = arr[i]
				arr[i] = maxTemp
			}
		}
	}
	fmt.Println("后=", arr)

}

// BubbleSortMaxToMin
//
//	@Description: 冒泡排序：倒序
//	@param arr
func BubbleSortMaxToMin(arr [10]int) {
	fmt.Println("前=", arr)
	// 临时变量
	var minTemp = 0
	// 排序次数
	for times := 0; times < len(arr)-1; times++ {
		// 每次遍历将最小值往前冒泡
		for i := 0; i < len(arr)-1-times; i++ {
			//如果前面的比后面小，则交换
			if arr[i] < arr[i+1] {
				minTemp = arr[i]
				arr[i] = arr[i+1]
				arr[i+1] = minTemp
			}
		}
	}
	fmt.Println("后=", arr)
}
